package com.yt.system.controller;

import com.github.pagehelper.Page;
import com.yt.system.domain.*;
import com.yt.system.service.ActiveService;
import com.yt.system.service.HistoryService;
import com.yt.system.utils.PageHelperUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author Clqv
 * @create 2019--09--18 15:58
 */
@Api("活动模块接口")
@RestController
@RequestMapping("/active")
public class ActiveController {

    @Autowired
    public ActiveService activeService;

    @Autowired
    public HistoryService historyService;

//------------------------------------------------------------------活动基本接口--------------------------------------------------------------------------------------
    /**
     * 参加活动的接口
     * 根据活动类型先判断是小组参加还是个人参加
     * @param aid 账户id
     * @param actid 活动id
     * @return
     * 若程序出错导致无法插入信息而参加失败，返回0
     * 若报名成功返回1
     * 若不符合报名时间，返回2
     * 若参加人数已到达上限，返回3
     * 若此用户已参加过此活动，返回4
     */
    @ApiOperation(value = "参加活动；参数：用户id，活动id；若程序出错导致无法插入信息而参加失败，返回0；若报名成功返回1；" +
            "若不符合报名时间，返回2；若参加小组数/人数已到达上限，返回3；若此用户/小组已参加过此活动，返回4")
    @PostMapping("/join")
    public Integer joinActive(@RequestParam("aid") Integer aid, @RequestParam("actid") Integer actid){
        System.out.println("参加活动");
        System.out.println("aid:"+aid+"  "+"actid:"+actid);
        Activity activity = activeService.getActiveBykey(actid);
        Integer flag = 0;
        System.out.println(activity);
        Integer type = activity.getActivitytype().getAcflag();
        if (type==1){
            System.out.println("个人参赛");
            flag = activeService.joinActiveForOne(aid,actid);
            System.out.println("flag:"+flag);
        }else {
            System.out.println("组队参赛");
            flag = activeService.joinActiveForGroup(aid,actid);
            System.out.println("flag:"+flag);
        }
        return flag;
    }

    /**
     * 用户退出活动的接口
     * @param aid 用户id
     * @param actid 活动id
     * @return
     * 返回1则为退出成功，返回2则为用户未参加此活动,返回3则为活动已经进行,否则就是退出失败
     */
    @ApiOperation(value = "退出活动；参数：用户id，活动id；返回1则为退出成功，返回2则为用户未参加此活动,返回3则为活动已经进行,否则就是退出失败")
    @PutMapping("/takeout")
    public Integer takeoutActive(@RequestParam("aid") Integer aid, @RequestParam("actid") Integer actid){
        System.out.println("退出活动");
        Activity activity = activeService.getActiveBykey(actid);
        Integer flag = 0;
        Integer type = activity.getActivitytype().getAcflag();
        if (type==1){
            flag = activeService.takeoutActiveForOne(aid,actid);
        }else {
            flag = activeService.takeoutActiveForGroup(aid,actid);
        }
        return flag;
    }

    /**
     * 用户查询个人参加活动记录
     * @param aid 用户id
     * @return
     * 用户查询到的参加个人参加活动的记录
     */
    @ApiOperation(value = "查询个人参加的活动；参数：用户id；返回该用户所有的参加活动的记录，分页对象：具体的分页参数")
    @GetMapping("/getActiveByaid")
    public List<AccountActivity> getActiveByaid(@RequestParam("aid") Integer aid){
        System.out.println("查询用户个人参加的活动信息");
        List<AccountActivity> accountActivities = activeService.getActiveByaid(aid);
        System.out.println(activeService.getActiveByaid(aid));
        return accountActivities;
    }


    /**
     * 查询所有未结束的活动信息
     * @return
     * 返回所有未结束的活动信息
     */
    @ApiOperation(value = "查询所有未结束的活动；参数：分页对象：具体的分页参数；返回所有未结束的的活动记录")
    @GetMapping("/getActives")
    public PageVO<Object> getActives(PageQO pageQO){
        System.out.println("查询所有未结束的活动");
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        activeService.getActives();
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    /**
     * 查询所有未开始的活动信息
     * @return
     * 返回所有未开始的活动信息
     */
    @ApiOperation(value = "查询所有未开始的活动；参数：分页对象：具体的分页参数；返回所有未结束的的活动记录")
    @GetMapping("/getActivesNoStart")
    public PageVO<Object> getActivesNoStart(PageQO pageQO){
        System.out.println("查询所有未开始的活动");
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        activeService.getActivesNoStart();
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    /**
     * 查询所有进行中的活动信息
     * @return
     * 返回所有进行中的活动信息
     */
    @ApiOperation(value = "查询所有进行中的活动；参数：分页对象：具体的分页参数；返回所有未结束的的活动记录")
    @GetMapping("/getActivesStarted")
    public PageVO<Object> getActivesStarted(PageQO pageQO){
        System.out.println("查询所有进行中的活动");
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        activeService.getActivesStarted();
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }


    /**
     * 查询所有已结束的活动信息
     * @return
     * 返回所有的活动信息
     */
    @ApiOperation(value = "查询所有已结束的活动；参数：分页对象：具体的分页参数；返回所有已结束的的活动记录")
    @GetMapping("/getEndActives")
    public PageVO<Object> getEndActives(PageQO pageQO){
        System.out.println("查询所有已结束的活动");
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        activeService.getActivesforEnd();
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }


    /**
     * 查询某个活动的所有参赛信息，可根据其中一条获得该活动的具体信息
     * @param actid 活动id
     * @return
     * 返回该活动的所有具体参赛信息
     */
    @ApiOperation(value = "查询某个活动的所有参加信息；参数：活动id；返回该活动的所有具体参加信息，可根据某条记录获得该活动的信息")
    @GetMapping("/getAccountActivitysByActid")
    public List<AccountActivity> getAccountActivitysByActid(@RequestParam("actid") Integer actid){
        System.out.println("查询某个活动的具体信息以及参加人员名单");
        List<AccountActivity> accountActivities = new ArrayList<>();
        Activity activity = activeService.getActiveBykey(actid);
        Integer type = activity.getActivitytype().getAcflag();
        if (type==1){
            System.out.println("查看个人活动参加信息");
            accountActivities  = activeService.getAccountActivitysByActid(actid);
        }else {
            System.out.println("查看小组活动参加信息");
            accountActivities = activeService.getAccountActivitysByActidForgroup(actid);
        }
        return accountActivities;
    }

    /**
     * 查询某个活动的详情
     * @param actid 活动id
     * @return
     * 返回该活动的所有的详情
     */
    @ApiOperation(value = "查询某个活动的详情；参数：活动id；返回该活动的所有的详情")
    @GetMapping("/getActiveByActid")
    public Activity getActiveByActid(Integer actid){
        Activity activity = activeService.getActiveBykey(actid);
        return activity;
    }

    /**
     * 推迟活动时间
     * @param actid 活动id
     * @param startTime 推迟后的时间,要求传入的时间格式：yyyy-MM-dd hh:mm:ss
     * @return
     * 返回1为推迟成功，否则为推迟失败
     */
    @ApiOperation(value = "推迟活动时间；参数：活动id，推迟的时间；返回1则为推迟成功，返回2则为传入结束时间小于传入开始时间，3为传入开始时间小于原本开始时间，" +
            "4为该活动已开始，不可推迟；0为推迟失败")
    @PutMapping("/pushStartTime")
    public Integer pushActiveTime(@RequestParam("actid") Integer actid, @RequestParam("startTime") String startTime,@RequestParam("endTime") String endTime){
        System.out.println("推迟活动时间");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date starttime = null;
        Date endtime = null;
        try {
            starttime = sdf.parse(startTime);
            endtime = sdf.parse(endTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Integer flag = activeService.pushActiveTime(actid,starttime,endtime);
        return flag;
    }

    /**
     * 发布活动
     * @param activity
     * @return
     * 返回1为发布成功，返回2为开始时间大于结束时间，返回3为系统时间大于开始时间，0为系统错误，发布失败
     */
    @ApiOperation(value = "发布活动；参数：活动对象；返回1为发布成功，返回2为开始时间大于结束时间，返回3为系统时间大于开始时间，0为系统错误，发布失败")
    @PostMapping("/publishActive")
    public Integer PublishActive(@RequestBody Activity activity){
        System.out.println("发布活动："+activity);
        Integer flag = activeService.publishActive(activity);
        return flag;
    }

    /**
     * 更新活动信息
     * @param activity
     * @return
     * 返回1为更新成功，返回2为开始时间大于结束时间，返回3为系统时间大于开始时间，0为系统错误，更新失败
     */
    @ApiOperation(value = "更新活动；参数：活动对象；返回1为更新成功，返回2为开始时间大于结束时间，返回3为系统时间大于开始时间，0为系统错误，更新失败")
    @PostMapping("/updateActive")
    public Integer updateActive(@RequestBody Activity activity){
        System.out.println("更新活动信息："+activity);
        Integer flag = activeService.updateActive(activity);
        return flag;
    }

    /**
     * 删除活动信息
     * @param actid
     * @return
     * 返回1为删除成功，返回2为活动已开始但未结束，不能删除,返回0为系统错误，删除失败
     */
    @ApiOperation("删除活动；参数：活动id；返回1为删除成功，返回2为活动已开始但未结束，不能删除,返回0为系统错误，删除失败")
    @DeleteMapping("/deleteActive")
    public Integer deleteActive(@RequestParam("actid") Integer actid){
        System.out.println("删除活动："+actid);
        Integer flag = activeService.deleteActive(actid);
        return flag;
    }

    /**
     * 开启/关闭系统自动强制参加
     * @param actid 活动id
     * @param flag 标识，0为开启，1为关闭
     * @return
     * 返回1为关闭成功；2为关闭失败，活动开始前30分钟内不能再关闭；3为开启成功；4为开启失败，在活动开始前15分钟不能开启此功能
     */
    @ApiOperation("开启/关闭系统自动强制参加；参数：活动id，标识符flag，flag=1为关闭，0为开启；返回1为关闭成功；2为关闭失败，活动开始前30分钟内不能再关闭；3为开启成功；4为开启失败，在活动开始前15分钟不能开启此功能")
    @PutMapping("/updateForceJoin")
    public Integer updateForceJoin(@RequestParam("actid") Integer actid,@RequestParam("flag") Integer flag){
        if (flag==1){
            System.out.println("flag："+flag+"关闭活动系统自动强制参加："+actid);
        }else {
            System.out.println("flag："+flag+"开启活动系统自动强制参加"+actid);
        }
        Integer flag1 = activeService.updateForceJoin(actid,flag);
        return flag1;
    }

    /**
     * 根据关键字模糊查询
     * @param keywords
     * @return
     * 返回模糊查询后的结果
     */
    @ApiOperation("根据关键字模糊查询；参数：关键字；返回模糊查询后的结果")
    @GetMapping("/searchActiveByKeyWord")
    public List<Activity> searchActiveByKeyWord(String keywords){
        System.out.println("根据关键字模糊查询："+keywords);
        List<Activity> activities = activeService.searchActiveByName(keywords);
        return activities;
    }

//---------------------------------------------------------------活动类型接口------------------------------------------------------------------
    /**
     * 查询所有的活动类型
     * @return
     * 返回所有的活动类型信息
     */
    @ApiOperation("查询所有的活动类型；参数：无；返回所有的活动类型信息")
    @GetMapping("/getActiveTypes")
    public List<Activitytype> getActiveTypes(){
        System.out.println("查询所有的活动类型");
        List<Activitytype> activitytypes = activeService.getActiveTypes();
        return activitytypes;
    }

    /**
     * 添加新的活动类型
     * @param activitytype 活动类型对象
     * @return
     * 返回1为添加成功，返回0为系统错误，添加失败
     */
    @ApiOperation("添加新的活动类型；参数：活动类型对象；返回1为添加成功，返回0为系统错误，添加失败")
    @PostMapping("/addActiveType")
    public Integer addActiveType(@RequestBody Activitytype activitytype){
        System.out.println("添加新的活动类型："+activitytype);
        Integer flag = activeService.addActiveType(activitytype);
        return flag;
    }

    /**
     * 更新活动类型
     * @param activitytype 活动类型对象
     * @return
     * 返回1为更新成功，返回0为系统错误，更新失败
     */
    @ApiOperation("更新活动类型；参数：活动类型对象；返回1为更新成功，返回0为系统错误，更新失败")
    @PutMapping("/updateActiveType")
    public Integer updateActiveType(@RequestBody Activitytype activitytype){
        System.out.println("更新活动类型："+activitytype);
        Integer flag = activeService.updateActiveType(activitytype);
        return flag;
    }

    /**
     * 删除活动类型
     * @param acid 活动类型id
     * @return
     * 返回1删除成功
     */
    @ApiOperation("删除活动类型；参数：活动类型id；返回1为删除成功，返回2为有该活动类型的活动未结束，不能删除，返回0为系统错误，删除失败")
    @DeleteMapping("/deleteActiveType")
    public Integer deleteActiveType(@RequestParam("acid") Integer acid){
        System.out.println("删除活动类型："+acid);
        Integer flag = activeService.deleteActiveType(acid);
        return flag;
    }



//----------------------------------------------------------------------------------------------活动投票接口------------------------------------------------------------------------------

    /**
     * 开启投票
     * @param actid 活动id
     * @return
     * 返回1是开启成功，返回2是不符合开启时间要求，必须在活动开始半小时后才能开启投票，返回3为此活动已开启投票，不能再开
     */
    @ApiOperation("开启投票；参数：活动id；返回1是开启成功，返回2是不符合开启时间要求，必须在活动开始半小时后才能开启投票，返回3为此活动已开启投票，不能再开启")
    @PostMapping("/startVote")
    public Integer startVote(@RequestParam("actid") Integer actid){
        System.out.println("开启该活动投票："+actid);
        Integer flag = activeService.startVote(actid);
        return flag;
    }


    /**
     * 获得该活动的投票记录
     * @param actid 活动id
     * @return
     * 返回该活动的投票记录
     */
    @ApiOperation("获得该活动所有的投票记录；参数：无；返回该活动的投票记录")
    @GetMapping("/getVotes")
    public List<Vote> getVotes(@RequestParam("actid") Integer actid){
        System.out.println("查询该活动:"+actid+"所有的投票记录");
        List<Vote> votes = activeService.getVotes(actid);
        return votes;
    }

    /**
     * 获得该活动的投票记录
     * @param actid 活动id
     * @return
     * 返回该活动的投票记录
     */
    @ApiOperation("获得该活动前十条的的投票记录；参数：无；返回该活动的投票记录")
    @GetMapping("/getVotesBefore")
    public List<Vote> getVotesBefore(@RequestParam("actid") Integer actid){
        System.out.println("查询该活动:"+actid+"前十条的投票记录");
        List<Vote> votes = activeService.getVotesBefore(actid);
        return votes;
    }

    /**
     * 投票
     * @param actid 活动id
     * @param aid 投票者id
     * @param vid 所投记录id
     * @return
     * 返回1为投票成功，返回2为此用户已投过票，返回3则为该活动投票功能已关闭
     */
    @ApiOperation("投票；参数：活动id，投票者id，所投记录id；返回1为投票成功，返回2为此用户已投过票，返回3则为该活动投票功能已关闭")
    @PostMapping("/Voted")
    public Integer Voted(@RequestParam("actid") Integer actid,@RequestParam("aid") Integer aid,@RequestParam("vid") Integer vid){
        System.out.println("在"+actid+"中"+aid+"投票给"+vid);
        Integer flag = activeService.Voted(actid,aid,vid);
        return flag;
    }

//    /**
//     * 关闭投票功能
//     * 系统计算排名，获得相应积分
//     * @param actid 活动id
//     * @return
//     * 返回1为关闭投票成功，系统已自动结算结果；返回2为该活动没有开启投票；
//     */
//    @ApiOperation("关闭投票功能；参数：活动id；返回1为关闭投票成功，系统已自动结算结果；返回2为该活动没有开启投票；")
//    @PostMapping("/finishVote")
//    public Integer finishVote(@RequestParam("actid") Integer actid){
//        System.out.println("关闭活动："+actid+"的投票功能");
//        Integer flag = 0;
//        flag = activeService.finishVote(actid);
//        return flag;
//    }



}
